/*
 * Copyright 1999-2018 Alibaba Group Holding Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.alibaba.csp.sentinel.slots.block.degrade;

import java.util.List;

import com.alibaba.csp.sentinel.Entry;
import com.alibaba.csp.sentinel.context.Context;
import com.alibaba.csp.sentinel.node.DefaultNode;
import com.alibaba.csp.sentinel.slotchain.AbstractLinkedProcessorSlot;
import com.alibaba.csp.sentinel.slotchain.ProcessorSlot;
import com.alibaba.csp.sentinel.slotchain.ResourceWrapper;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import com.alibaba.csp.sentinel.slots.block.degrade.circuitbreaker.CircuitBreaker;
import com.alibaba.csp.sentinel.spi.SpiOrder;

/**
 * A {@link ProcessorSlot} dedicates to circuit breaking.
 *
 * @author Carpenter Lee
 * @author Eric Zhao
 */
@SpiOrder(-1000)
public class DegradeSlot extends AbstractLinkedProcessorSlot<DefaultNode> {

    @Override
    public void entry(Context context, ResourceWrapper resourceWrapper, DefaultNode node, int count,
                      boolean prioritized, Object... args) throws Throwable {
        /**
         * 这里是降级的限流规则检测，使用的是断路器来实现的，降级的规则有：
         * 可设置当慢调用比例达到配置的指定值的时候
         * 可设置当异常数达到配置的值得时候
         * 可设置当异常数达到配置的值得时候
         * 如果配置了上面的一种就，如果达到降级的条件就可以进行降级，降级的时长为配置的时长
         *
         * 降级规则这里使用的是熔断器来实现的，如果没有达到降级规则，熔断器的状态是关闭状态，可以放心请求
         * 当达到降级规则的时候，熔断器将被打开，当熔断器打开的时候，如果这个时候来了请求，那么就会判断当前熔断时长是否已经达到，如果
         * 达到了熔断时长，那么这个时候就先放过这个请求，并且熔断器是半开状态，如果这个请求正常执行成功以后，那么这个时候的熔断器就是
         * 关闭状态，如果这个请求还是达到了降级的条件，那么熔断器就由半开状态变为打开状态
         *
         * 方法performChecking只做了两件事
         * 1.首先判断熔断器是否是关闭状态，如果是关闭状态，直接放过这个请求；
         * 2.如果熔断器是打开状态，那么在判断熔断时长是否已经达到了指定的熔断时长，如果是则将熔断器由打开状态变为半开状态，并且放过这个请求；
         * 3.如果熔断时长没有达到配置的熔断时长，那么这个请求将会被丢弃；
         * 方法exit在资源回收的时候做的事情就是判断这个请求是否是慢调用、异常比例、异常数等有一个条件如果是满足的，也就是
         * 达到了降级条件，那么这个时候判断：
         * 1.如果熔断器是关闭状态，则打开熔断器；
         * 2.如果熔断器是半开状态，这个请求是放过的一个请求还是达到了降级条件，那么熔断器由半开修改为打开；
         * 3.如果熔断器是打开状态，直接返回；
         */

        performChecking(context, resourceWrapper);

        fireEntry(context, resourceWrapper, node, count, prioritized, args);
    }

    void performChecking(Context context, ResourceWrapper r) throws BlockException {
        //根据资源名称获取断路器的降级规则
        List<CircuitBreaker> circuitBreakers = DegradeRuleManager.getCircuitBreakers(r.getName());
        if (circuitBreakers == null || circuitBreakers.isEmpty()) {
            return;
        }
        for (CircuitBreaker cb : circuitBreakers) {
            //断路器的判断，这里的判断分为两步，打开和关闭
            //打开的时候判断熔断时长是否达到指定的时长，如果达到将断路器置为半开并放过这个请求，如果没有达到熔断时长则放弃这个请求
            //关闭的时候直接放过这个请求
            if (!cb.tryPass(context)) {
                throw new DegradeException(cb.getRule().getLimitApp(), cb.getRule());
            }
        }
    }

    @Override
    public void exit(Context context, ResourceWrapper r, int count, Object... args) {
        Entry curEntry = context.getCurEntry();
        if (curEntry.getBlockError() != null) {
            fireExit(context, r, count, args);
            return;
        }
        List<CircuitBreaker> circuitBreakers = DegradeRuleManager.getCircuitBreakers(r.getName());
        if (circuitBreakers == null || circuitBreakers.isEmpty()) {
            fireExit(context, r, count, args);
            return;
        }

        //如果没有出现BlokException则进入资源回收的逻辑
        if (curEntry.getBlockError() == null) {
            // passed request
            for (CircuitBreaker circuitBreaker : circuitBreakers) {
                //这里的断路器有两个，一个是异常数和异常比例的处理，一个是RT（响应时间也就是慢调用比例的判断）的处理
                //ExceptionCircuitBreaker:处理异常比例和异常数的熔断器
                //ResponseTimeCircuitBreaker：响应时间的RT的熔断器
                circuitBreaker.onRequestComplete(context);
            }
        }

        fireExit(context, r, count, args);
    }
}
